﻿using System;
using System.ComponentModel;
using System.Data;
using System.Threading;
using System.Windows.Forms;
using BUS;
using DevExpress.XtraGrid.Views.Base;
using Entity;
using DevExpress.XtraGrid.Localization;
using DevExpress.XtraEditors.Controls;
using Ultilities;
using DevExpress.XtraGrid.Views.Grid;
using Ultilities;
using System.Collections;

// ReSharper disable once CheckNamespace
namespace SalonManager
{
    public partial class FrmServiceType : BaseForm
    {
        #region Constructor

        ServiceType _svType;

        public FrmServiceType()
        {
            InitializeComponent();
            Load += FrmServiceType_Load;
            StatusOfForm = FormStatus.View;
            gridView.ValidateRow += gridView_ValidateRow;
            gridView.InvalidRowException += gridView_InvalidRowException;
            gridView.ShowingEditor += gridView_ShowingEditor;

            bw.DoWork += bw_DoWork;
            bw.RunWorkerCompleted += bw_RunWorkerCompleted;

            SetToolbarButton(TabpageName.Category, false, false, false, true, false, true);
            SetToolbarButton(TabpageName.Action, true, false, false, false, false, true);
        }

        #endregion

        #region Add to BackgroundWorker

        private void BwGridLoadTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    bw.RunWorkerAsync(Tasks.GRID_LOAD); // Thêm một process vào bw với tham số FORM_LOAD
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

        private void BwAddNewItemTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    if (Permission.CanAdd) //Permission.CanAdd)
                    {
                        bw.RunWorkerAsync(Tasks.ITEM_ADDNEW);
                    }
                    else
                    {
                        ErpMessageBoxEX.Show(Messages.USER_RIGHT_CANNOT_ADD, Text, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        fncRefresh();
                    }
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

        private void BwUpdateItemTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    if (Permission.CanEdit)
                    {
                        bw.RunWorkerAsync(Tasks.ITEM_UPDATE);
                    }
                    else
                    {
                        ErpMessageBoxEX.Show(Messages.USER_RIGHT_CANNOT_EDIT, Text, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        fncRefresh();
                    }
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

// ReSharper disable once UnusedMember.Global
        public void BwLoadItemTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    bw.RunWorkerAsync(Tasks.ITEM_LOAD);
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

        private void BwDeleteItemTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    if (Permission.CanDelete)
                    {
                        bw.RunWorkerAsync(Tasks.ITEM_DELETE);
                    }
                    else
                    {
                        ErpMessageBoxEX.Show(Messages.USER_RIGHT_CANNOT_DEL, Text, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        fncRefresh();
                    }
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

// ReSharper disable once UnusedMember.Global
        public void BwLoadComboBoxTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    bw.RunWorkerAsync(Tasks.COMBOBOX_LOAD);
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

// ReSharper disable once UnusedMember.Global
        public void BwLoadOtherTask()
        {
            try
            {
                while (bw.IsBusy)
                {
                    Application.DoEvents(); // Nếu ứng dụng mình còn process nào đang chạy, thì vẫn tiếp tục chạy đồng thời thực hiện thêm tác vụ tiếp theo
                    Thread.Sleep(Globals.DEFAULT_SLEEPTIME); // Nhưng 1 khoảng thời gian nhằm mục đích focus đến process đang chạy, rồi mới thực hiện process dưới
                }
                lock (this)
                {
                    bw.RunWorkerAsync(Tasks.OTHERS);
                }
            }
            catch (Exception ex)
            {
                Erp_ExceptionHandler(ex);
            }
        }

        #endregion

        #region BackgroundWorker

        void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            Cursor = Cursors.WaitCursor;
            var arrArgumentOfBw = new ArrayList();
            var svTypeBus = new ServiceTypeBus();
            arrArgumentOfBw.Add(e.Argument);
            try
            {
                switch ((Tasks)e.Argument)
                {
                    case Tasks.COMBOBOX_LOAD:
                        {
                            #region Combobox Load



                            #endregion
                            break;
                        }
                    case Tasks.GRID_LOAD:
                        {
                            #region Grid Load

                            StatusText = Messages.STATUS_LOADING;
                            
                            var dt = svTypeBus.GetAllServiceType();

                            arrArgumentOfBw.Add(dt);                            

                            #endregion
                            break;
                        }
                    case Tasks.ITEM_ADDNEW:
                        {
                            #region Item Addnew

                            StatusText = Messages.STATUS_INSERT;

                            string result = svTypeBus.InsertServiceType(_svType);
                            arrArgumentOfBw.Add(result);

                            DataTable dt = svTypeBus.GetServiceTypeByCode(_svType.ServiceTypeCode);
                            if (dt.Rows.Count > 0)
                                _svType.ServiceTypeID = Globals.intParse(dt.Rows[0][ServiceTypeEnt.FIELD_SERVICETYPE_ID]);

                            #endregion
                            break;
                        }
                    case Tasks.ITEM_UPDATE:
                        {
                            #region Item Update

                            StatusText = Messages.STATUS_UPDATE;

                            string result = svTypeBus.UpdateServiceType(_svType);
                            arrArgumentOfBw.Add(result);

                            #endregion
                            break;
                        }
                    case Tasks.ITEM_LOAD:
                        {
                            #region Item Load


                            #endregion
                            break;
                        }
                    case Tasks.ITEM_DELETE:
                        {
                            #region Item Delete

                            StatusText = Messages.STATUS_DELETE;

                            string result = svTypeBus.DeleteServiceType(_svType.ServiceTypeID);
                            arrArgumentOfBw.Add(result);

                            #endregion
                            break;
                        }

                    case Tasks.OTHERS:
                        {
                            #region Others

                            StatusText = Messages.STATUS_UPDATE;

                            #endregion
                            break;
                        }

                    default:
                        {
                            break;
                        }
                }
            }
            catch (Exception ex)
            {
                arrArgumentOfBw.Add(ex);
            }
            finally
            {
                e.Result = arrArgumentOfBw;
            }
        }

        void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled == false)
            {
                var arrArgumentOfBw = (ArrayList)e.Result;
                try
                {
                    if (!e.Cancelled)
                    {
                        switch ((Tasks)arrArgumentOfBw[0])
                        {
                            case Tasks.COMBOBOX_LOAD:
                                {

                                    break;
                                }

                            case Tasks.GRID_LOAD:
                                {
                                    #region GRID_LOAD

                                    var svTypes = arrArgumentOfBw[1];
                                    dtgView.DataSource = svTypes;

                                    StatusText = Messages.STATUS_LOADING_COMPLETE;
                                    #endregion
                                    break;
                                }

                            case Tasks.ITEM_ADDNEW:
                                {
                                    #region Item AddNew

                                    string result = arrArgumentOfBw[1].ToString();
                                    if (result == "0")
                                    {
                                        StatusText = Messages.STATUS_INSERT_COMPLETE;

                                        for (int i = 0; i < gridView.RowCount; i++)
                                        {
                                            if (gridView.GetRowCellValue(i, ServiceTypeEnt.FIELD_SERVICETYPE_CODE)
                                                    .ToString() == _svType.ServiceTypeCode)
                                            {
                                                gridView.SetRowCellValue(i, ServiceTypeEnt.FIELD_SERVICETYPE_ID, _svType.ServiceTypeID);
                                                break;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        StatusText = Messages.STATUS_INSERT_ERROR;
                                    }

                                    #endregion
                                    break;
                                }
                            case Tasks.ITEM_UPDATE:
                                {
                                    #region Item Update

                                    string result = arrArgumentOfBw[1].ToString();
                                    StatusText = result == "0" ? Messages.STATUS_UPDATE_COMPLETE : Messages.STATUS_UPDATE_ERROR;

                                    #endregion
                                    break;
                                }
                            case Tasks.ITEM_LOAD:
                                {
                                    #region Item Load

                                    #endregion
                                    break;
                                }
                            case Tasks.ITEM_DELETE:
                                {
                                    #region Item Delete

                                    string result = arrArgumentOfBw[1].ToString();
                                    StatusText = result == "0" ? Messages.STATUS_DELETE_COMPLETE : Messages.STATUS_DELETE_ERROR;

                                    #endregion
                                    break;
                                }

                            case Tasks.OTHERS:
                                {
                                    #region Others

                                    StatusText = Messages.STATUS_UPDATE_COMPLETE;

                                    #endregion
                                    break;
                                }

                            default:
                                {
                                    break;
                                }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Erp_ExceptionHandler(ex);
                }
                finally
                {
                    Cursor = Cursors.Default;
                }
            }
        }

        #endregion

        #region Grid Event

        void gridView_ShowingEditor(object sender, CancelEventArgs e)
        {
            var grid = (GridView)sender;
            if (!grid.IsNewItemRow(grid.FocusedRowHandle))
            {
                if (grid.FocusedColumn.Name.Equals(ServiceTypeEnt.FIELD_SERVICETYPE_CODE))
                    e.Cancel = true;
            }
        }

        void gridView_InvalidRowException(object sender, InvalidRowExceptionEventArgs e)
        {
            e.ExceptionMode = ExceptionMode.NoAction;
        }

        void gridView_ValidateRow(object sender, ValidateRowEventArgs e)
        {
            try
            {
                var view = sender as GridView;
                string err = "";
                bool isValid = true;
                if (gridView.GetRowCellValue(e.RowHandle, ServiceTypeEnt.FIELD_SERVICETYPE_CODE).ToString().Trim() == "")
                {
                    err += Messages.ID_IS_NOT_NULL + "\n";
                    isValid = false;
                }
                if (gridView.GetRowCellValue(e.RowHandle, ServiceTypeEnt.FIELD_SERVICETYPE_NAME).ToString().Trim() == "")
                {
                    err += Messages.NAME_IS_NOT_NULL + "\n";
                    isValid = false;
                }

                if (isValid)
                {
                    if (view != null)
                    {
                        _svType = new ServiceType
                        {
                            ServiceTypeCode = view.GetRowCellValue(e.RowHandle, ServiceTypeEnt.FIELD_SERVICETYPE_CODE).ToString().Trim(),
                            ServiceTypeName = view.GetRowCellValue(e.RowHandle, ServiceTypeEnt.FIELD_SERVICETYPE_NAME).ToString().Trim(),
                            ServiceTypeID = Globals.intParse(view.GetRowCellValue(e.RowHandle, ServiceTypeEnt.FIELD_SERVICETYPE_ID))
                        };

                        if (e.RowHandle < 0)
                        {
                            //Check code
                            var svBus = new ServiceTypeBus();
                            DataTable dt = svBus.GetServiceTypeByCode(_svType.ServiceTypeCode);
                            if (dt.Rows.Count > 0)
                            {
                                view.SetColumnError(view.Columns[ServiceTypeEnt.FIELD_SERVICETYPE_CODE], Messages.CODE_HAS_BEEN_ALREADY_EXISTS);
                                throw new Exception();
                            }

                            BwAddNewItemTask();
                        }
                        else
                        {
                            BwUpdateItemTask();
                        }
                    }
                }
                else
                {
                    e.Valid = false;
                    Globals.ShowMessageBox(err, Text);
                }
            }
            catch (Exception)
            {
                e.Valid = false;
            }
        }

        #endregion

        #region Form Event

        void FrmServiceType_Load(object sender, EventArgs e)
        {
            try
            {
                GridLocalizer.Active = new MyGridLocalizer();
                BwGridLoadTask();
            }
            catch (Exception ex)
            {
                MessageBox.Show(HandleException.HandleSQLException(ex.Message), Text);
            }
        }

        #endregion

        #region Override Methods

        public override void fncDelete()
        {
            if (gridView.SelectedRowsCount > 0)
            {
                if (ErpMessageBoxEX.Show(Messages.DELETE_CONFIRM_QUESTION, Text, MessageBoxButtons.YesNo,MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    _svType = new ServiceType
                    {
                        ServiceTypeID = Globals.intParse(gridView.GetRowCellValue(gridView.FocusedRowHandle,
                            ServiceTypeEnt.FIELD_SERVICETYPE_ID))
                    };

                    BwDeleteItemTask();
                }
            }
        }

        public override void fncRefresh()
        {
            BwGridLoadTask();
        }

        #endregion
    }
}
